home *** CD-ROM | disk | FTP | other *** search
/ Dictionaries & Language / Dictionaries and Language (Chestnut CD-ROM) (1993).iso / spell / pcspell / spellup2.pa4 < prev   
Encoding:
Text File  |  1988-03-29  |  8.8 KB  |  265 lines
  1. PROGRAM SPELLUP2;  { SPELL CHECKER DICTIONARY UPDATE }
  2. {
  3. Update the file SPELLER.LIS (spelling dictionary) by adding words
  4. contained in an alphabetical file "filename.MIS".  SPELLUPD.COM and
  5. SPELLER.LIS should be in the current directory. The prior file SPELLER.LIS
  6. is renamed to SPELLER.LI$ and a new SPELLER.LIS is created.
  7.  
  8. Version SPELLUP2 changes:  In this version of SPELLUPD the command line may
  9. include a second parameter.  If it does then the file named in the second
  10. parameter is updated instead of the default SPELLER.LIS.  This allows for
  11. using an alternate dictionary with SPELLER2.EXE and updating the alternate
  12. dictionary with this program also. In this version of SPELLUPD the program
  13. does NOT make a backup of the word list being updated and the new word list
  14. replaces the present list by making the changes dynamicly to the file. This
  15. allows the updated file to replace the old file so that a single floppy disk
  16. can be used for the update. Also in this version the new word list word
  17. is checked for equal to the word in the spelling list. If they are EQUAL then
  18. the word is deleted from the spelling list. This allows for correcting the
  19. spelling list by deleting incorrect words if they are found.
  20. SPELLUP2 is converted for Turbo 4.0.
  21.  
  22. J. Leeson   March 29, 1988
  23.  
  24. }
  25.  
  26.   CONST
  27.     Bufsize = 16384;
  28.     Size : word = Bufsize;
  29.     Listsize = 4096;
  30.     ListArraySize = 4130; {Listsize + 34}
  31.   VAR
  32.     List : array[1..ListArraySize] of char;
  33.     NewWordsBuf : array[1..Listsize] of char;
  34.     Active, Ahead : array[1..Bufsize] of char;
  35.     WordList : File;     {untyped for block read/write}
  36.     NewWords : text;     {the new words to add}
  37.     NRP, NWP : longint;  {seek variables}
  38.     ListIndex, ActiveIndex : integer;  {indeces to arrays}
  39.     Result : word;       {number of records read/written}
  40.     WordListName, NewWordsName : string;
  41.  
  42.     ListWord, NewWord : string;
  43.     Done : boolean;
  44.     EndActive, EndAhead : boolean;
  45.     CR : char;
  46.     LF : char;
  47.  
  48. { ************************************************************************ }
  49. { ******** Initialize the buffers and buffer variables ******************* }
  50. { ************************************************************************ }
  51.  
  52.   procedure Initialize;
  53.   begin
  54.     CR := chr(13);  LF := chr(10);
  55.     NRP := 0; NWP := 0;     {note: These are zero orig variables}
  56.     ListIndex := 1; ActiveIndex := 1;
  57.     BlockRead(WordList, Active, Size, Result);
  58.     NRP := NRP + Result;       {note: Result is one orig so NRP always
  59.                                 points to next zero orig byte to read}
  60.     if Result = Size then begin
  61.       EndActive := False;
  62.       BlockRead(WordList, Ahead, Size, Result);
  63.       if Result = Size then EndAhead := false else EndAhead := true;
  64.       NRP := NRP + Result;
  65.     end else EndActive := true;
  66.   end;
  67.  
  68. { ************************************************************************ }
  69. { ******** Get a word from the list of new words or return nul *********** }
  70. { ************************************************************************ }
  71.  
  72.   procedure GetNewWord;
  73.   begin
  74.     if not eof(NewWords) then Readln (NewWords, NewWord)
  75.       else NewWord := '';
  76.   end;
  77.  
  78. { ************************************************************************ }
  79. { ** Shuffle the read buffers : move Ahead to Active and refill Ahead **** }
  80. { ************************************************************************ }
  81.  
  82.   procedure PushBuf;
  83.   begin
  84.     EndActive := EndAhead;
  85.     Active := Ahead;
  86.     Seek (WordList, NRP);
  87.     BlockRead (WordList, Ahead, Size, Result);
  88.     NRP := NRP + Result;
  89.     if Result = Size then EndAhead := false else EndAhead := true;
  90.     ActiveIndex := 1;
  91.   end;
  92.  
  93. { ************************************************************************ }
  94. { ** Extract a word from the Active buffer and check for end of buffer *** }
  95. { ************************************************************************ }
  96.  
  97.   procedure GetListWord;
  98.     VAR
  99.       EOW : boolean;
  100.       I : integer;
  101.       temp : char;
  102.   begin
  103.     ListWord := '';
  104.     EOW := false;
  105.     while not EOW do begin
  106.       if ActiveIndex > Bufsize then begin
  107.         if EndActive then begin             {should never happen}
  108.           EOW := true;
  109.           exit;
  110.         end else PushBuf;
  111.       end;
  112.       temp := Active[ActiveIndex];
  113.       ActiveIndex := ActiveIndex+1;
  114.       if (temp=LF) or (temp=chr(26)) or (temp=chr(0)) then EOW := true
  115.         else if temp <> CR then ListWord := ListWord + temp;
  116.     end; {while}
  117.   end;
  118.  
  119. { ************************************************************************ }
  120. { ********** Put a word into the List array and update WordList ********** }
  121. { ************************************************************************ }
  122.  
  123. Procedure Stuff (Aword : string);
  124. Var x : word;
  125.     i : integer;
  126.     Temp : string;
  127. begin
  128.    Temp := Aword + CR + LF;
  129.    x := length (Temp);
  130.    for I := 1 to x do begin
  131.       List[ListIndex] := Temp[I];
  132.       ListIndex := ListIndex + 1;
  133.    end;
  134.    if ListIndex > Listsize then begin
  135.       Seek (WordList, NWP);
  136.       BlockWrite (WordList, List, Listsize);
  137.       NWP := NWP + Listsize;
  138.       for I := 1 to ListIndex - Listsize do List[I] := List[Listsize + I];
  139.       ListIndex := ListIndex - Listsize;
  140.    end;
  141. end;
  142.  
  143. { ************************************************************************ }
  144. { *********** Copy the rest of WordList to the output file *************** }
  145. { ************************************************************************ }
  146.  
  147. Procedure CopyList;
  148. begin
  149.    Stuff (ListWord);
  150.    Repeat
  151.       if ListIndex > Listsize then begin
  152.          Listindex := 1;
  153.          Seek (WordList, NWP);
  154.          BlockWrite (WordList, List, Listsize);
  155.          NWP := NWP + Listsize;
  156.       end;
  157.       if ActiveIndex > Bufsize then PushBuf;
  158.       List[ListIndex] := Active[ActiveIndex];
  159.       ActiveIndex := ActiveIndex + 1;
  160.       ListIndex := ListIndex + 1;
  161.    Until (List[ListIndex-1] = chr(26)) or (List[ListIndex-1] = chr(0));
  162.    Done := true;
  163. end;
  164.  
  165. { ************************************************************************ }
  166. { *********** Copy the rest of NewWords to the output file *************** }
  167. { ************************************************************************ }
  168.  
  169. Procedure CopyNew;
  170. begin
  171.    Stuff (NewWord);
  172.    While not EOF (NewWords) do begin
  173.       Readln (NewWords, NewWord);
  174.       Stuff (NewWord);
  175.    end;
  176.    Done := true;
  177. end;
  178.  
  179. { ************************************************************************ }
  180. { ************************  Main Program  ******************************** }
  181. { ************************************************************************ }
  182.  
  183. begin
  184.  
  185. if ParamCount = 0 then begin
  186.     Writeln ('Enter the fully qualified name of');
  187.     Writeln ('the file where the list of words to');
  188.     Writeln ('be added to the dictionary file is');
  189.     Writeln ('located (eg: d:path\name.MIS)');
  190.     Writeln;
  191.     Readln (NewWordsName);
  192.     WordListName := '';
  193.     writeln ('Enter the name of the dictionary');
  194.     writeln ('file to be updated.');
  195.     writeln ('(Default is SPELLER.LIS)');
  196.     writeln;
  197.     Readln (WordListName);
  198.     if WordListName = '' then WordListName := 'SPELLER.LIS';
  199.     end
  200. else begin
  201.     NewWordsName := ParamStr (1);
  202.     if ParamCount =1 then WordListName := 'SPELLER.LIS'
  203.         else WordListName := ParamStr (2);
  204.     end;
  205. Writeln ('Opening file :  ', NewWordsName);
  206. Assign (NewWords, NewWordsName);
  207. SetTextBuf (NewWords, NewWordsBuf);
  208. {$I-}
  209. Reset (NewWords);
  210. {$I+}
  211. If IOResult <> 0 then begin
  212.   Writeln; Writeln ('File error in opening ', WordListName);
  213.   exit;
  214. end;
  215. Writeln ('Opening file: ', WordListName);
  216. Assign (WordList, WordListName);
  217. {$I-}
  218. Reset (WordList, 1);
  219. {$I+}
  220. If IOResult <> 0 then begin
  221.   Writeln; Writeln ('File error in opening ', WordListName);
  222.   exit;
  223. end;
  224. if SizeOf (NewWords) > Bufsize then begin
  225.    Writeln; Writeln ('List of new words file is too large for');
  226.    Writeln ('update. Split it into files no larger');
  227.    Writeln ('than 16K bytes.');
  228.    Writeln; Writeln ('Program terminating.');
  229.    Close (NewWords);
  230.    Exit;
  231. end;
  232. Write ('UPDATING'); WRITELN; WRITELN;
  233.  
  234. Initialize;
  235. Done := false;
  236. GetNewWord;
  237. GetListWord;
  238. repeat
  239.   if (ListWord='') and (NewWord='') then Done := true
  240.   else begin
  241.     if ListWord = '' then CopyNew;
  242.     if NewWord = '' then CopyList;
  243.     if not done then begin
  244.       if ListWord < NewWord then begin
  245.         Stuff (ListWord);
  246.         GetListWord;
  247.       end else begin
  248.         if ListWord = NewWord then begin
  249.           GetListWord;
  250.           writeln ('Deleting word  ', NewWord);
  251.         end else Stuff (NewWord);
  252.         GetNewWord;
  253.       end;
  254.     end;
  255.   end;
  256. until Done;
  257.  
  258. Close (NewWords);
  259. ListWord := chr(26)+chr(0);
  260. Stuff (ListWord);
  261. Seek (WordList, NWP);
  262. BlockWrite (WordList, List, ListIndex);
  263. Close (WordList);
  264. End.
  265.